```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Spring中的设计模式 | 技术小馆</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.6;
            background-color: #f9f9f9;
        }
        h1, h2, h3, h4, h5, h6 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: #222;
        }
        .hero {
            background: linear-gradient(135deg, #6e8efb, #a777e3);
        }
        .card {
            transition: transform 0.3s ease, box-shadow 0.3s ease;
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 20px rgba(0,0,0,0.1);
        }
        .pattern-icon {
            font-size: 2.5rem;
            color: #6e8efb;
        }
        .drop-cap::first-letter {
            float: left;
            font-size: 3.5rem;
            line-height: 1;
            margin: 0.15em 0.1em 0 0;
            font-weight: bold;
            color: #6e8efb;
        }
        .section-divider {
            border: none;
            height: 1px;
            background: linear-gradient(90deg, transparent, #ddd, transparent);
        }
        .footer-link {
            transition: color 0.3s ease;
        }
        .footer-link:hover {
            color: #a777e3;
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <section class="hero text-white py-20 px-4 md:px-0">
        <div class="container mx-auto max-w-4xl text-center">
            <h1 class="text-4xl md:text-5xl font-bold mb-6">Spring中的设计模式</h1>
            <p class="text-xl md:text-2xl opacity-90 mb-8">探索Spring框架背后的设计哲学与优雅实现</p>
            <div class="w-24 h-1 bg-white bg-opacity-50 mx-auto mb-8"></div>
            <p class="text-lg max-w-2xl mx-auto">
                Spring框架中广泛应用了多种设计模式，它们不仅解决了特定问题，还提高了代码的可维护性、可扩展性和灵活性。从创建型到结构型再到行为型，设计模式贯穿了整个Spring框架。
            </p>
        </div>
    </section>

    <!-- Main Content -->
    <main class="container mx-auto max-w-6xl px-4 py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <div class="bg-white rounded-xl shadow-md overflow-hidden card">
                <div class="p-8">
                    <div class="drop-cap">
                        <p>在Spring框架中，设计模式的应用十分广泛，它们不仅用于解决特定问题，还帮助提高代码的可维护性、可扩展性和灵活性。从基本的创建型模式到行为型模式，再到结构型模式，Spring框架中涵盖了各种类型的设计模式。</p>
                    </div>
                    <div class="my-6">
                        <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1714099068147-18729473-a93f-4462-8946-731f93a4abd5.png" alt="Spring设计模式概览" class="rounded-lg w-full h-auto">
                    </div>
                    <p>设计模式的应用使得Spring框架具有了许多独特的特性和功能。例如，依赖注入模式使得组件之间的依赖关系更加松散，提高了代码的灵活性和可测试性；控制反转模式使得应用程序更加灵活，并且可以方便地更改对象之间的依赖关系；而面向切面编程模式则使得在应用程序中实现横切关注点更加容易。</p>
                </div>
            </div>
        </section>

        <!-- Overview Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 text-center">Spring中的主要设计模式</h2>
            <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
                <!-- Singleton Pattern Card -->
                <div class="bg-white rounded-xl shadow-md p-6 card">
                    <div class="text-center mb-4">
                        <i class="fas fa-cubes pattern-icon"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3 text-center">单例模式</h3>
                    <p class="text-gray-600 mb-4">确保一个类只有一个实例，并提供全局访问点，Spring中Bean的默认作用域。</p>
                    <a href="#singleton" class="text-blue-500 font-medium hover:text-blue-700 transition-colors">了解更多 →</a>
                </div>
                
                <!-- Factory Pattern Card -->
                <div class="bg-white rounded-xl shadow-md p-6 card">
                    <div class="text-center mb-4">
                        <i class="fas fa-industry pattern-icon"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3 text-center">工厂模式</h3>
                    <p class="text-gray-600 mb-4">封装对象创建逻辑，隐藏实例化过程，如BeanFactory和ApplicationContext。</p>
                    <a href="#factory" class="text-blue-500 font-medium hover:text-blue-700 transition-colors">了解更多 →</a>
                </div>
                
                <!-- Observer Pattern Card -->
                <div class="bg-white rounded-xl shadow-md p-6 card">
                    <div class="text-center mb-4">
                        <i class="fas fa-bell pattern-icon"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3 text-center">观察者模式</h3>
                    <p class="text-gray-600 mb-4">定义对象间一对多依赖关系，如Spring的事件监听机制。</p>
                    <a href="#observer" class="text-blue-500 font-medium hover:text-blue-700 transition-colors">了解更多 →</a>
                </div>
                
                <!-- Strategy Pattern Card -->
                <div class="bg-white rounded-xl shadow-md p-6 card">
                    <div class="text-center mb-4">
                        <i class="fas fa-chess-knight pattern-icon"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3 text-center">策略模式</h3>
                    <p class="text-gray-600 mb-4">定义算法族并封装，使它们可以互相替换，如@Autowired注入策略。</p>
                    <a href="#strategy" class="text-blue-500 font-medium hover:text-blue-700 transition-colors">了解更多 →</a>
                </div>
                
                <!-- Iterator Pattern Card -->
                <div class="bg-white rounded-xl shadow-md p-6 card">
                    <div class="text-center mb-4">
                        <i class="fas fa-list-ol pattern-icon"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3 text-center">迭代器模式</h3>
                    <p class="text-gray-600 mb-4">提供顺序访问聚合对象元素的方法，隐藏内部表示，如BeanDefinition遍历。</p>
                    <a href="#iterator" class="text-blue-500 font-medium hover:text-blue-700 transition-colors">了解更多 →</a>
                </div>
                
                <!-- Other Patterns Card -->
                <div class="bg-white rounded-xl shadow-md p-6 card">
                    <div class="text-center mb-4">
                        <i class="fas fa-shapes pattern-icon"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3 text-center">其他模式</h3>
                    <p class="text-gray-600 mb-4">代理模式、模板方法、适配器模式等在Spring中也有广泛应用。</p>
                    <a href="#others" class="text-blue-500 font-medium hover:text-blue-700 transition-colors">了解更多 →</a>
                </div>
            </div>
        </section>

        <hr class="section-divider my-12">

        <!-- Singleton Pattern Section -->
        <section id="singleton" class="mb-16">
            <div class="bg-white rounded-xl shadow-md overflow-hidden card">
                <div class="p-8">
                    <div class="flex items-center mb-6">
                        <i class="fas fa-cubes text-3xl mr-4 text-blue-500"></i>
                        <h2 class="text-3xl font-bold">单例模式</h2>
                    </div>
                    <div class="prose max-w-none">
                        <p>单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。这种模式通常用于需要全局访问的类，例如工厂类、日志类、线程池等。</p>
                        <div class="my-6">
                            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1714099152220-23c3f818-ad3f-43fa-9f5c-e9efc01e06a2.png" alt="单例模式" class="rounded-lg w-full h-auto">
                        </div>
                        <p>在Spring框架中，单例模式得到了广泛的应用，主要体现在以下几个方面：</p>
                        <ul class="list-disc pl-6 space-y-2 my-4">
                            <li><strong>Bean的默认作用域：</strong> 在Spring中，Bean的默认作用域是单例模式（Singleton）。当Spring容器初始化时，会根据配置文件或注解来创建Bean的实例，并且这些实例都是单例的，即在整个Spring容器中只有一个实例存在。这样可以保证多个对象之间共享同一个Bean实例，节省系统资源。</li>
                            <li><strong>BeanFactory和ApplicationContext：</strong> 在Spring中，BeanFactory和ApplicationContext都是单例模式的，它们负责管理和维护所有的Bean对象，并提供对Bean的创建、获取、销毁等操作。在Spring应用程序中，通常只会存在一个BeanFactory或ApplicationContext实例，这样可以确保整个应用程序中的Bean都是同一个实例，从而保证了整个应用程序的一致性和稳定性。</li>
                            <li><strong>单例Bean的注入：</strong> 在Spring中，单例Bean可以注入到其他Bean中，这样就可以在多个地方共享同一个Bean实例。通过在配置文件或注解中定义依赖关系，Spring容器可以自动将单例Bean注入到其他Bean中，从而实现了依赖注入（DI）和控制反转（IOC）的功能。</li>
                            <li><strong>单例Bean的线程安全性：</strong> Spring容器保证了单例Bean的线程安全性，即在多线程环境下，多个线程访问同一个单例Bean时不会发生线程安全问题。Spring容器在创建单例Bean时会采取一些措施来确保其线程安全性，例如使用同步机制或线程安全的容器等。</li>
                        </ul>
                    </div>
                </div>
            </div>
        </section>

        <hr class="section-divider my-12">

        <!-- Factory Pattern Section -->
        <section id="factory" class="mb-16">
            <div class="bg-white rounded-xl shadow-md overflow-hidden card">
                <div class="p-8">
                    <div class="flex items-center mb-6">
                        <i class="fas fa-industry text-3xl mr-4 text-blue-500"></i>
                        <h2 class="text-3xl font-bold">工厂模式</h2>
                    </div>
                    <div class="prose max-w-none">
                        <p>工厂模式是一种创建型设计模式，旨在提供一种封装对象创建逻辑的方式，从而隐藏了具体对象的实例化过程。它通过一个工厂类来负责创建对象，将对象的创建与使用相分离，使得客户端无需关心对象的实际创建过程，只需要通过工厂类获取所需的对象即可。</p>
                        <div class="my-6">
                            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1714099208249-a89616c4-c9f9-4c6e-a467-a23c58069cfe.png" alt="工厂模式" class="rounded-lg w-full h-auto">
                        </div>
                        <p>工厂模式通常包含以下几个关键角色：</p>
                        <ul class="list-disc pl-6 space-y-2 my-4">
                            <li><strong>抽象工厂（Abstract Factory）：</strong> 定义了创建产品对象的接口，包含一组用于创建对象的方法。</li>
                            <li><strong>具体工厂（Concrete Factory）：</strong> 实现了抽象工厂接口，负责具体对象的创建。</li>
                            <li><strong>抽象产品（Abstract Product）：</strong> 定义了产品对象的接口，描述了产品的特性和行为。</li>
                            <li><strong>具体产品（Concrete Product）：</strong> 实现了抽象产品接口，是具体对象的实例。</li>
                        </ul>
                        <h3 class="text-2xl font-bold mt-8 mb-4">Spring中的应用场景：</h3>
                        <ul class="list-disc pl-6 space-y-2">
                            <li><strong>BeanFactory和ApplicationContext接口：</strong> 这两个接口可以被视为工厂接口，负责管理和创建bean对象。它们提供了一种机制来获取bean实例，并隐藏了bean的创建细节。</li>
                            <li><strong>FactoryBean接口：</strong> FactoryBean是Spring框架提供的一个重要接口，用于创建复杂对象或者代理对象。通过实现FactoryBean接口，开发者可以自定义对象的创建过程，从而实现一些复杂的逻辑，如动态代理、延迟初始化等。</li>
                            <li><strong>@Autowired和@Resource注解：</strong> 这两个注解常用于将bean对象注入到其他对象中，从而实现依赖注入。当Spring容器在初始化bean时，会根据注解的要求从容器中获取所需的bean实例，这就是一种工厂模式的应用。</li>
                            <li><strong>FactoryBean接口的实现类：</strong> Spring框架提供了许多实现了FactoryBean接口的类，如JdbcTemplate, RestTemplate等。通过这些类，可以在Spring容器中创建和管理复杂的对象，并且可以自定义对象的创建过程。</li>
                            <li><strong>条件注解的工厂选择：</strong> Spring框架提供了一系列的条件注解，如@Conditional、@Profile等，可以根据条件选择性地创建对象。这种条件化的对象创建机制也可以视为一种工厂模式的应用。</li>
                        </ul>
                    </div>
                </div>
            </div>
        </section>

        <hr class="section-divider my-12">

        <!-- Observer Pattern Section -->
        <section id="observer" class="mb-16">
            <div class="bg-white rounded-xl shadow-md overflow-hidden card">
                <div class="p-8">
                    <div class="flex items-center mb-6">
                        <i class="fas fa-bell text-3xl mr-4 text-blue-500"></i>
                        <h2 class="text-3xl font-bold">观察者模式</h2>
                    </div>
                    <div class="prose max-w-none">
                        <p>观察者模式是一种行为设计模式，用于定义对象之间的一对多依赖关系，使得当一个对象的状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。</p>
                        <div class="my-6">
                            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1714099265658-3540ac81-2ad9-4af0-af96-33b30853c2cc.png" alt="观察者模式" class="rounded-lg w-full h-auto">
                        </div>
                        <p>在观察者模式中，存在两种核心角色：</p>
                        <ul class="list-disc pl-6 space-y-2 my-4">
                            <li><strong>Subject（主题）：</strong> 主题是被观察的对象，它维护一系列观察者对象，并提供了添加、删除和通知观察者的方法。</li>
                            <li><strong>Observer（观察者）：</strong> 观察者是依赖于主题的对象，它定义了一个更新接口，使得在主题状态发生变化时可以得到通知并执行相应的操作。</li>
                        </ul>
                        <h3 class="text-2xl font-bold mt-8 mb-4">Spring中的应用场景：</h3>
                        <ul class="list-disc pl-6 space-y-2">
                            <li><strong>事件监听器（Application Event）：</strong> Spring框架提供了一种基于事件的通信机制，即应用事件。开发者可以定义自己的事件，并通过发布事件的方式通知所有监听该事件的观察者。在这种模式下，发布者充当主题，监听器充当观察者，实现了一种松耦合的事件驱动模型。</li>
                            <li><strong>Spring事件机制：</strong> Spring框架本身就是一个大的观察者模式的实现，它通过事件驱动的方式管理和协调各个组件之间的交互。当某个重要事件发生时，如容器初始化完成、Bean加载完成等，Spring容器会发布相应的事件，并通知所有注册的监听器。</li>
                            <li><strong>Spring的ApplicationContext：</strong> ApplicationContext是Spring容器的核心接口之一，它本身就是一个观察者模式的实现。ApplicationContext维护了一系列Bean定义和BeanPostProcessor对象，并在Bean的生命周期中发布各种事件。开发者可以通过注册监听器的方式来响应这些事件，并在适当的时候执行自定义的逻辑。</li>
                            <li><strong>Spring Boot Starter机制：</strong> Spring Boot Starter是一种依赖管理的机制，它将常用的一组依赖打包成一个单独的Starter模块，并提供了自动配置的功能。在这种模式下，Starter模块充当主题，自动配置类充当观察者，通过监听各种事件来动态调整应用程序的配置。</li>
                        </ul>
                    </div>
                </div>
            </div>
        </section>

        <hr class="section-divider my-12">

        <!-- Strategy Pattern Section -->
        <section id="strategy" class="mb-16">
            <div class="bg-white rounded-xl shadow-md overflow-hidden card">
                <div class="p-8">
                    <div class="flex items-center mb-6">
                        <i class="fas fa-chess-knight text-3xl mr-4 text-blue-500"></i>
                        <h2 class="text-3xl font-bold">策略模式</h2>
                    </div>
                    <div class="prose max-w-none">
                        <p>策略模式是一种行为设计模式，它定义了一系列算法，并将每个算法封装到具有共同接口的独立类中，使得它们可以互相替换。在策略模式中，客户端通过委托给不同的策略对象来实现不同的行为，从而实现了算法的解耦和动态切换。</p>
                        <div class="my-6">
                            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1714100851580-84a4ea84-e475-4c7f-bdeb-a55dc1cbfcaf.png" alt="策略模式" class="rounded-lg w-full h-auto">
                        </div>
                        <p>策略模式通常包含以下几个角色：</p>
                        <ul class="list-disc pl-6 space-y-2 my-4">
                            <li><strong>Context（上下文）：</strong> 上下文类负责维护对策略对象的引用，并提供了一个用于切换算法的接口。客户端通过上下文对象来选择和应用不同的策略。</li>
                            <li><strong>Strategy（策略）：</strong> 策略接口定义了一组算法的通用行为，具体的策略类实现了这个接口，并提供了具体的算法实现。</li>
                        </ul>
                        <h3 class="text-2xl font-bold mt-8 mb-4">Spring中的应用场景：</h3>
                        <ul class="list-disc pl-6 space-y-2">
                            <li><strong>@Autowired注解：</strong> 在Spring中，@Autowired注解可以与@Qualifier注解一起使用，实现对特定实现类的选择和注入。通过@Qualifier注解，可以指定要注入的具体实现类，从而实现了在运行时动态切换策略的目的。</li>
                            <li><strong>@Conditional注解：</strong> Spring框架提供了@Conditional注解来实现条件化的Bean装配，可以根据特定的条件选择性地装配Bean。这种方式类似于策略模式，通过在不同的条件下选择不同的实现类，从而实现了动态选择和切换策略的功能。</li>
                            <li><strong>Spring MVC中的HandlerMapping和HandlerAdapter：</strong> Spring MVC框架中的HandlerMapping和HandlerAdapter就是策略模式的应用。HandlerMapping负责将URL映射到具体的处理器(Controller)，而HandlerAdapter负责调用具体的处理器方法，并返回结果给客户端。通过配置不同的HandlerMapping和HandlerAdapter，可以根据请求的不同选择不同的处理策略，实现了灵活的请求处理。</li>
                        </ul>
                    </div>
                </div>
            </div>
        </section>

        <hr class="section-divider my-12">

        <!-- Iterator Pattern Section -->
        <section id="iterator" class="mb-16">
            <div class="bg-white rounded-xl shadow-md overflow-hidden card">
                <div class="p-8">
                    <div class="flex items-center mb-6">
                        <i class="fas fa-list-ol text-3xl mr-4 text-blue-500"></i>
                        <h2 class="text-3xl font-bold">迭代器模式</h2>
                    </div>
                    <div class="prose max-w-none">
                        <p>迭代器模式是一种行为型设计模式，它用于提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。迭代器模式将遍历的责任交给了迭代器对象，使得聚合对象和迭代算法能够相互独立地变化。</p>
                        <div class="my-6">
                            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1714100793369-69fc73ab-46f8-4a59-8ef0-4589032e820b.png" alt="迭代器模式" class="rounded-lg w-full h-auto">
                        </div>
                        <p>在Spring框架中，迭代器模式得到了广泛的应用，主要体现在以下几个方面：</p>
                        <ul class="list-disc pl-6 space-y-2 my-4">
                            <li><strong>集合框架中的迭代器：</strong> Spring框架本身使用了大量的集合类来存储各种信息，例如BeanDefinition、BeanDefinitionRegistry等。这些集合类都实现了迭代器模式，提供了统一的遍历方式，使得客户端代码可以方便地对这些信息进行遍历和操作。</li>
                            <li><strong>BeanDefinition的获取：</strong> 在Spring中，BeanDefinition表示了一个Bean的定义信息，包括了Bean的类名、属性值等。Spring提供了多种方式来获取BeanDefinition，例如BeanDefinitionRegistry接口的getBeanDefinitionNames()方法和getBeanDefinition()方法，这些方法返回了一个BeanDefinition的迭代器，客户端可以通过迭代器遍历所有的BeanDefinition信息。</li>
                            <li><strong>注解扫描器：</strong> Spring框架中的注解扫描器（AnnotationBeanDefinitionScanner）也使用了迭代器模式。它可以扫描指定包下的所有类，并提取出带有指定注解的类信息。通过使用迭代器，注解扫描器可以逐个检查类是否带有指定注解，并将符合条件的类信息返回给客户端。</li>
                            <li><strong>BeanPostProcessor接口：</strong> 在Spring中，BeanPostProcessor接口用于在Bean实例化之后和初始化之前对Bean进行额外的处理。BeanPostProcessor接口定义了两个方法：postProcessBeforeInitialization()和postProcessAfterInitialization()。当Spring容器初始化一个Bean时，会调用所有注册的BeanPostProcessor的这两个方法，通过使用迭代器，Spring能够按照注册的顺序依次调用这些方法，实现对Bean的统一处理。</li>
                        </ul>
                    </div>
                </div>
            </div>
        </section>

        <hr class="section-divider my-12">

        <!-- Other Patterns Section -->
        <section id="others" class="mb-16">
            <div class="bg-white rounded-xl shadow-md overflow-hidden card">
                <div class="p-8">
                    <div class="flex items-center mb-6">
                        <i class="fas fa-shapes text-3xl mr-4 text-blue-500"></i>
                        <h2 class="text-3xl font-bold">其他设计模式</h2>
                    </div>
                    <div class="prose max-w-none">
                        <p>在Spring框架中，还有多种设计模式被广泛应用，以下是其中一些主要的设计模式以及具体应用的地方：</p>
                        <div class="my-6">
                            <div class="mermaid">
                                graph TD
                                    A[Spring设计模式] --> B[创建型模式]
                                    A --> C[结构型模式]
                                    A --> D[行为型模式]
                                    B --> B1(单例模式)
                                    B --> B2(工厂模式)
                                    B --> B3(建造者模式)
                                    C --> C1(代理模式)
                                    C --> C2(适配器模式)
                                    C --> C3(装饰器模式)
                                    D --> D1(观察者模式)
                                    D --> D2(策略模式)
                                    D --> D3(模板方法模式)
                                    D --> D4(迭代器模式)
                            </div>
                        </div>
                        <ul class="list-disc pl-6 space-y-2 my-4">
                            <li><strong>代理模式（Proxy Pattern）：</strong> Spring的AOP（面向切面编程）就是基于代理模式实现的，通过动态代理实现横切逻辑，解耦业务逻辑和横切逻辑。</li>
                            <li><strong>模板方法模式（Template Method Pattern）：</strong> Spring的JdbcTemplate和HibernateTemplate等模板类，提供了模板方法，简化了数据库操作和Hibernate操作。</li>
                            <li><strong>适配器模式（Adapter Pattern）：</strong> Spring的适配器用于将现有的接口转换为需要的接口，使得不兼容的类能够一起工作，例如HandlerAdapter用于处理不同类型的处理器（Controller）。</li>
                            <li><strong>装饰器模式（Decorator Pattern）：</strong> Spring中的装饰器模式在AOP中被广泛应用，通过动态代理和增强来实现对原有业务逻辑的增强。</li>
                            <li><strong>责任链模式（Chain of Responsibility Pattern）：</strong> Spring Security中的过滤器链就是一个典型的责任链模式的应用，用于处理不同类型的安全拦截。</li>
                            <li><strong>组合模式（Composite Pattern）：</strong> Spring中的ApplicationContext容器是一个典型的组合模式，可以包含多个Bean定义，形成一个层次化的容器结构。</li>
                        </ul>
                        <p class="mt-6">这些设计模式的应用，使得Spring框架变得灵活、可扩展且易于维护。同时，Spring提供了许多功能和特性，帮助开发人员更好地利用这些设计模式来构建可靠的应用程序。</p>
                    </div>
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-white py-8">
        <div class="container mx-auto px-4 text-center">
            <div class="mb-4">
                <h3 class="text-xl font-bold">技术小馆</h3>
            </div>
            <div>
                <a href="http://www.yuque.com/jtostring" class="footer-link text-gray-300 hover:text-white">http://www.yuque.com/jtostring</a>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```